#![forbid(unsafe_code)]

// 导入安全FFI模块
use safe_ffi::{SafeMemoryBuffer, SafeCString, FFIResult, FFIError};
use safe_ffi::callback::{register_string_callback, execute_callback, unregister_callback};
use safe_ffi::config::{Config, ConfigValue, SafeZenrsConfig};
use safe_ffi::utils::{StringUtils, NumberUtils, CopyUtils};

// 主函数示例
pub fn run_basic_example() -> Result<(), Box<dyn std::error::Error>> {
    // 1. 展示SafeMemoryBuffer的基本用法
    println!("=== 1. SafeMemoryBuffer基本用法 ===");
    basic_memory_buffer()?;
    
    // 2. 展示SafeCString的基本用法
    println!("\n=== 2. SafeCString基本用法 ===");
    basic_c_string()?;
    
    // 3. 展示配置管理功能
    println!("\n=== 3. 配置管理功能 ===");
    config_management()?;
    
    // 4. 展示回调功能
    println!("\n=== 4. 回调功能 ===");
    callback_management()?;
    
    // 5. 展示工具函数
    println!("\n=== 5. 工具函数 ===");
    utility_functions()?;
    
    println!("\n所有示例执行成功!");
    Ok(())
}

// SafeMemoryBuffer基本用法示例
fn basic_memory_buffer() -> FFIResult<()> {
    // 创建一个新的内存缓冲区
    let mut buffer = SafeMemoryBuffer::new(1024)?;
    println!("创建了一个大小为 {} 的内存缓冲区", buffer.size());
    
    // 写入数据
    let data = "Hello, Safe FFI!".as_bytes();
    buffer.copy_from_slice(data)?;
    println!("写入数据: {:?}", data);
    
    // 读取数据
    let read_data = buffer.as_slice();
    println!("读取数据: {:?}", &read_data[..data.len()]);
    
    // 验证数据是否正确
    assert_eq!(&read_data[..data.len()], data);
    println!("数据验证通过!");
    
    // 创建子缓冲区
    let sub_buffer = buffer.sub_buffer(0, data.len())?;
    println!("创建子缓冲区，大小: {}", sub_buffer.size());
    
    Ok(())
}

// SafeCString基本用法示例
fn basic_c_string() -> FFIResult<()> {
    // 创建一个C字符串
    let c_string = SafeCString::new("Hello, Safe C String!")?;
    println!("创建C字符串: {:?}", c_string.as_str());
    
    // 获取C风格指针
    let c_ptr = c_string.as_ptr();
    println!("C风格指针地址: {:p}", c_ptr);
    
    // 检查字符串长度
    let len = c_string.len();
    println!("字符串长度: {}", len);
    
    // 验证字符串内容
    let rust_str = c_string.to_string_lossy();
    println!("转换为Rust字符串: {}", rust_str);
    assert_eq!(rust_str, "Hello, Safe C String!");
    
    Ok(())
}

// 配置管理功能示例
fn config_management() -> FFIResult<()> {
    // 创建配置对象
    let mut config = Config::new();
    println!("创建新的配置对象");
    
    // 设置配置值
    config.set("app.name", ConfigValue::String("safe-ffi-example".to_string()))?;
    config.set("app.version", ConfigValue::String("1.0.0".to_string()))?;
    config.set("app.debug", ConfigValue::Bool(true))?;
    config.set("app.max_connections", ConfigValue::Uint(100))?;
    println!("设置配置值完成");
    
    // 获取配置值
    let name = config.get("app.name")?.as_string()?;
    let version = config.get("app.version")?.as_string()?;
    let debug = config.get("app.debug")?.as_bool()?;
    let max_connections = config.get("app.max_connections")?.as_uint()?;
    
    println!("应用配置:");
    println!("  名称: {}", name);
    println!("  版本: {}", version);
    println!("  调试模式: {}", debug);
    println!("  最大连接数: {}", max_connections);
    
    // 序列化配置
    let serialized = config.serialize()?;
    println!("配置序列化后大小: {} 字节", serialized.len());
    
    // 反序列化配置
    let deserialized = Config::deserialize(&serialized)?;
    println!("配置反序列化成功");
    
    // 验证反序列化结果
    let deserialized_name = deserialized.get("app.name")?.as_string()?;
    assert_eq!(deserialized_name, "safe-ffi-example");
    println!("反序列化结果验证通过");
    
    // 使用FFI安全配置接口
    let safe_config_ptr = SafeZenrsConfig::create()?;
    println!("创建了安全配置对象，指针地址: {:p}", safe_config_ptr);
    
    // 设置配置值
    SafeZenrsConfig::set(
        safe_config_ptr,
        "ffi.test_value",
        ConfigValue::String("This is a test value".to_string())
    )?;
    println!("通过安全FFI接口设置配置值");
    
    // 获取配置值
    let test_value = SafeZenrsConfig::get(safe_config_ptr, "ffi.test_value")?;
    println!("通过安全FFI接口获取配置值: {:?}", test_value.as_string()?);
    
    // 序列化安全配置
    let safe_serialized = SafeZenrsConfig::serialize(safe_config_ptr)?;
    println!("安全配置序列化后大小: {} 字节", safe_serialized.len());
    
    // 释放安全配置对象
    SafeZenrsConfig::free(safe_config_ptr)?;
    println!("安全配置对象已释放");
    
    Ok(())
}

// 回调功能示例
fn callback_management() -> Result<(), Box<dyn std::error::Error>> {
    // 注册一个字符串处理回调
    let callback_id = register_string_callback(|input| {
        println!("回调收到输入: {}", input);
        format!("处理后的结果: {}", input.to_uppercase())
    })?;
    println!("注册字符串回调，ID: {}", callback_id);
    
    // 执行回调
    let input = "hello, callback!".as_bytes();
    let result = execute_callback(callback_id, input)?;
    let result_str = String::from_utf8(result)?;
    println!("回调执行结果: {}", result_str);
    
    // 注销回调
    unregister_callback(callback_id)?;
    println!("回调已注销");
    
    // 尝试执行已注销的回调（应该失败）
    let result = execute_callback(callback_id, input);
    match result {
        Err(e) => println!("预期的错误: {:?}", e),
        Ok(_) => panic!("应该失败的操作成功了"),
    }
    
    Ok(())
}

// 工具函数示例
fn utility_functions() -> FFIResult<()> {
    // 字符串工具示例
    let mut buffer = SafeMemoryBuffer::new(100)?;
    StringUtils::to_c_string("测试C字符串", &mut buffer)?;
    println!("C字符串转换结果: {:?}", buffer.as_slice());
    
    // 数值工具示例
    let mut num_buffer = SafeMemoryBuffer::new(8)?;
    NumberUtils::u64_to_bytes(123456789, &mut num_buffer)?;
    let num = NumberUtils::bytes_to_u64(&num_buffer)?;
    println!("数值转换: {} -> {} -> {}", 123456789, "二进制数据", num);
    
    // 复制工具示例
    let mut dest_buffer = SafeMemoryBuffer::new(50)?;
    let src_buffer = SafeMemoryBuffer::from_slice(&[1, 2, 3, 4, 5])?;
    let copy_size = CopyUtils::safe_copy(&mut dest_buffer, &src_buffer)?;
    println!("安全复制: 复制了 {} 字节", copy_size);
    
    // 验证复制结果
    let dest_slice = dest_buffer.as_slice();
    assert_eq!(&dest_slice[..copy_size], &[1, 2, 3, 4, 5]);
    println!("复制结果验证通过");
    
    Ok(())
}

// 主入口点（仅供测试使用）
#[cfg(test)]
mod tests {
    use super::*;
    
    #[test]
    fn test_basic_usage() {
        assert!(run_basic_example().is_ok());
    }
}